rochars / wavefile

 * wavefile

 * Read & write wave files with 4, 8, 11, 12, 16, 20, 24, 32 & 64-bit data.

 * Copyright (c) 2017-2018 Rafael da Silva Rocha.

 * https://github.com/rochars/wavefile

 *

 */

/** @private */

const bitDepth_ = require("bitdepth");

/** @private */

const riffChunks_ = require("riff-chunks");

/** @private */

const imaadpcm_ = require("imaadpcm");

/** @private */

const alawmulaw_ = require("alawmulaw");

/** @private */

const byteData_ = require("byte-data");

/** @private */

let uInt8_ = require("byte-data").uInt8;

/** @private */

let uInt16_ = require("byte-data").uInt16;

/** @private */

let uInt32_ = require("byte-data").uInt32;

/**

 * Class representing a wav file.

 */

class WaveFile {

    /**

     * @param {!Uint8Array|!Array<number>} bytes A wave file buffer.

     * @throws {Error} If no "RIFF" chunk is found.

     * @throws {Error} If no "fmt " chunk is found.

     * @throws {Error} If no "fact" chunk is found and "fact" is needed.

     * @throws {Error} If no "data" chunk is found.

     */

            this.fromBuffer(bytes);

        }

    }

    /**

     * Set up a WaveFile object based on the arguments passed.

     * @param {!number} numChannels The number of channels

     *     (Integer numbers: 1 for mono, 2 stereo and so on).

     * @param {!number} sampleRate The sample rate.

     *     Integer numbers like 8000, 44100, 48000, 96000, 192000.

     * @param {!string} bitDepth The audio bit depth.

     *     One of "4", "8", "8a", "8m", "16", "24", "32", "32f", "64"

     *     or any value between "8" and "32".

     * @param {!Array<number>} samples Array of samples to be written.

     *     The samples must be in the correct range according to the

     *     bit depth.

     * @throws {Error} If any argument does not meet the criteria.

     */

    fromScratch(numChannels, sampleRate, bitDepth, samples, options={}) {

        if (!options["container"]) {

            options["container"] = "RIFF";

        }

        // closest nuber of bytes if not / 8

        let numBytes = (((parseInt(bitDepth, 10) - 1) | 7) + 1) / 8;

        this.clearHeader_();

        this.bitDepth = bitDepth;

        // Normal PCM file header

        this.container = options["container"];

        this.chunkSize = 36 + samples.length * numBytes;

        this.format = "WAVE";

        this.fmt.chunkId = "fmt ";

        this.fmt.chunkSize = 16;

        this.fmt.byteRate = (numChannels * numBytes) * sampleRate;

        this.fmt.blockAlign = numChannels * numBytes;

        this.fmt.audioFormat = this.audioFormats_[bitDepth] ?

            this.audioFormats_[bitDepth] : 65534;

        this.fmt.numChannels = numChannels;

        this.fmt.sampleRate = sampleRate;

        this.fmt.bitsPerSample = parseInt(bitDepth, 10);

        this.data.chunkId = "data";

        this.data.samples = samples;

        // interleave the samples if they were passed de-interleaved

        if (samples.length > 0) {

            if (samples[0].constructor === Array) {

                this.isInterleaved = false;

                this.interleave();

            }

        }

        this.data.chunkSize = samples.length * numBytes;

        // IMA ADPCM header

        if (bitDepth == "4") {

            this.chunkSize = 44 + samples.length;

            this.fmt.chunkSize = 20;

            this.fmt.byteRate = 4055;

            this.fmt.blockAlign = 256;

            this.fmt.bitsPerSample = 4;

            this.fmt.cbSize = 2;

            this.fmt.validBitsPerSample = 505;

            this.fact.chunkId = "fact";

            this.fact.chunkSize = 4;

            this.fact.dwSampleLength = samples.length * 2;

            this.data.chunkSize = samples.length;

        }

        // A-Law and mu-Law header

        if (bitDepth == "8a" || bitDepth == "8m") {

            this.chunkSize = 44 + samples.length;

            this.fmt.chunkSize = 20;

            this.fmt.cbSize = 2;

            this.fmt.validBitsPerSample = 8;

            this.fact.chunkId = "fact";

            this.fact.chunkSize = 4;

            this.fact.dwSampleLength = samples.length;

        }

        // WAVE_FORMAT_EXTENSIBLE

        if (this.fmt.audioFormat == 65534) {

            this.chunkSize = 36 + 24 + samples.length * numBytes;

            this.fmt.chunkSize = 40;

            this.fmt.bitsPerSample = ((parseInt(bitDepth, 10) - 1) | 7) + 1;

            this.fmt.cbSize = 22;

            this.fmt.validBitsPerSample = parseInt(bitDepth, 10);

            this.fmt.dwChannelMask = 0;

            // subformat 128-bit GUID as 4 32-bit values

            // only supports uncompressed integer PCM samples

            this.fmt.subformat = [1, 1048576, 2852126848, 1905997824];

        }

    }

    /**

     * Init a WaveFile object from a byte buffer.

     * @param {!Uint8Array|!Array<number>} bytes The buffer.

     * @throws {Error} If container is not RIFF or RIFX.

     * @throws {Error} If no "fmt " chunk is found.

     * @throws {Error} If no "fact" chunk is found and "fact" is needed.

     * @throws {Error} If no "data" chunk is found.

     */

    fromBuffer(bytes) {

        this.readRIFFChunk_(bytes);

        let bigEndian = this.container == "RIFX";

        let chunk = riffChunks_.read(bytes, bigEndian);

        this.readFmtChunk_(chunk["subChunks"]);

        this.readFactChunk_(chunk["subChunks"]);

        this.readBextChunk_(chunk["subChunks"]);

        this.readCueChunk_(chunk["subChunks"]);

        this.readDataChunk_(

            chunk["subChunks"], {"be": bigEndian, "single": true});

        if (this.fmt.audioFormat == 3 && this.fmt.bitsPerSample == 32) {

            this.bitDepth = "32f";

        } else if (this.fmt.audioFormat == 6) {

            this.bitDepth = "8a";

        } else if (this.fmt.audioFormat == 7) {

            this.bitDepth = "8m";

        } else {

            this.bitDepth = this.fmt.bitsPerSample.toString();

        }

    }

    /**

     * Return a byte buffer representig the WaveFile object as a wav file.

     * The return value of this method can be written straight to disk.

     * @return {!Uint8Array} A .wav file.

     * @throws {Error} If any property of the object appears invalid.

     */

    toBuffer() {

        this.checkWriteInput_();

        this.assureInterleaved_();

        return this.createWaveFile_();

    }

    /**

     * Turn the file to RIFF.

     */

    toRIFF() {

        this.container = "RIFF";

        this.LEorBE_();

    }

    /**

     * Turn the file to RIFX.

     */

    toRIFX() {

        this.container = "RIFX";

        this.LEorBE_();

    }

    /**

     * Change the bit depth of the samples.

     * @param {!string} bitDepth The new bit depth of the samples.

     *      One of "8" ... "32" (integers), "32f" or "64" (floats)

     * @param {!boolean} changeResolution A boolean indicating if the

     *      resolution of samples should be actually changed or not.

     * @throws {Error} If the bit depth is not valid.

     */

    toBitDepth(bitDepth, changeResolution=true) {

        let toBitDepth = bitDepth;

        let thisBitDepth = this.bitDepth;

        if (!changeResolution) {

            toBitDepth = this.realBitDepth_(bitDepth);

            thisBitDepth = this.realBitDepth_(this.bitDepth);

        }

        this.assureInterleaved_();

        bitDepth_.toBitDepth(this.data.samples, thisBitDepth, toBitDepth);

        this.fromScratch(

            this.fmt.numChannels,

            this.fmt.sampleRate,

            bitDepth,

            this.data.samples,

            {"container": this.container}

        );

    }

    /**

     * Interleave multi-channel samples.

     */

    interleave() {

        if (!this.isInterleaved) {

            let finalSamples = [];

            let numChannels = this.data.samples[0].length;

            for (let i = 0; i < numChannels; i++) {

                for (let j = 0; j < this.data.samples.length; j++) {

                    finalSamples.push(this.data.samples[j][i]);

                }

            }

            this.data.samples = finalSamples;

            this.isInterleaved = true;    

        }

    }

    /**

     * De-interleave samples into multiple channels.

     */

    deInterleave() {

        if (this.isInterleaved) {

            let finalSamples = [];

            let i;

            for (i = 0; i < this.fmt.numChannels; i++) {

                finalSamples[i] = [];

            }

            let j;

            while (i < this.data.samples.length) {

                for (j = 0; j < this.fmt.numChannels; j++) {

                    finalSamples[j].push(this.data.samples[i+j]);

                }

                i += j;

            }

            this.data.samples = finalSamples;

            this.isInterleaved = false;

        }

    }

    /**

     * Encode a 16-bit wave file as 4-bit IMA ADPCM.

     * @throws {Error} If sample rate is not 8000.

     * @throws {Error} If number of channels is not 1.

     */

    toIMAADPCM() {

        if (this.fmt.sampleRate != 8000) {

            throw new Error(

                "Only 8000 Hz files can be compressed as IMA-ADPCM.");

            throw new Error(

                "Only mono files can be compressed as IMA-ADPCM.");

        } else {

            this.assure16Bit_();

            this.fromScratch(

                this.fmt.numChannels,

                this.fmt.sampleRate,

                "4",

                imaadpcm_.encode(this.data.samples),

                {"container": this.container}

            );

        }

    }

    /**

     * Decode a 4-bit IMA ADPCM wave file as a 16-bit wave file.

     */

    fromIMAADPCM() {

        this.fromScratch(

            this.fmt.numChannels,

            this.fmt.sampleRate,

            "16",

            imaadpcm_.decode(this.data.samples, this.fmt.blockAlign),

            {"container": this.container}

        );

    }

    /**

     * Encode 16-bit wave file as 8-bit A-Law.

     */

    toALaw() {

        this.assure16Bit_();

        this.assureInterleaved_();

        this.fromScratch(

            this.fmt.numChannels,

            this.fmt.sampleRate,

            "8a",

            alawmulaw_.alaw.encode(this.data.samples),

            {"container": this.container}

        );

    }

    /**

     * Decode a 8-bit A-Law wave file into a 16-bit wave file.

     */

    fromALaw() {

        this.fromScratch(

            this.fmt.numChannels,

            this.fmt.sampleRate,

            "16",

            alawmulaw_.alaw.decode(this.data.samples),

            {"container": this.container}

        );

    }

    /**

     * Encode 16-bit wave file as 8-bit mu-Law.

     */

    toMuLaw() {

        this.assure16Bit_();

        this.assureInterleaved_();

        this.fromScratch(

            this.fmt.numChannels,

            this.fmt.sampleRate,

            "8m",

            alawmulaw_.mulaw.encode(this.data.samples),

            {"container": this.container}

        );

    }

    /**

     * Decode a 8-bit mu-Law wave file into a 16-bit wave file.

     */

    fromMuLaw() {

        this.fromScratch(

            this.fmt.numChannels,

            this.fmt.sampleRate,

            "16",

            alawmulaw_.mulaw.decode(this.data.samples),

            {"container": this.container}

        );

    }

    /**

     * Return the closest greater number of bits for a number of bits that

     * do not fill a full sequence of bytes.

     * @param {!string} bitDepth The bit depth.

     * @return {!string}

     */

    realBitDepth_(bitDepth) {

        if (bitDepth != "32f") {

            bitDepth = (((parseInt(bitDepth, 10) - 1) | 7) + 1).toString();

        }

        return bitDepth;

    }

    /**

     * Validate the input for wav writing.

     * @throws {Error} If any property of the object appears invalid.

     * @private

     */

    checkWriteInput_() {

        this.validateBitDepth_();

        this.validateNumChannels_();

        this.validateSampleRate_();

    }

    /**

     * Validate the bit depth.

     * @return {!boolean} True is the bit depth is valid.

     * @throws {Error} If bit depth is invalid.

     * @private

     */

    validateBitDepth_() {

        if (!this.audioFormats_[this.bitDepth]) {

            if (parseInt(this.bitDepth, 10) > 8 &&

                    parseInt(this.bitDepth, 10) < 54) {

                return true;

            }

            throw new Error("Invalid bit depth.");

        }

        return true;

    }

    /**

     * Validate the number of channels.

     * @return {!boolean} True is the number of channels is valid.

     * @throws {Error} If the number of channels is invalid.

     * @private

     */

    validateNumChannels_() {

        let blockAlign = this.fmt.numChannels * this.fmt.bitsPerSample / 8;

        if (this.fmt.numChannels < 1 || blockAlign > 65535) {

            throw new Error("Invalid number of channels.");

        }

        return true;

    }

    /**

     * Validate the sample rate value.

     * @return {!boolean} True is the sample rate is valid.

     * @throws {Error} If the sample rate is invalid.

     * @private

     */

    validateSampleRate_() {

        let byteRate = this.fmt.numChannels *

            (this.fmt.bitsPerSample / 8) * this.fmt.sampleRate;

        if (this.fmt.sampleRate < 1 || byteRate > 4294967295) {

            throw new Error("Invalid sample rate.");

        }

        return true;

    }

    /**

     * Reset the attributes related to the "fact" chunk.

     * @private

     */

    clearHeader_() {

        this.fmt.cbSize = 0;

        this.fmt.validBitsPerSample = 0;

        this.fact.chunkId = "";

        this.fact.chunkSize = 0;

        this.fact.dwSampleLength = 0;

    }

    /**

     * Make the file 16-bit if it is not.

     * @private

     */

    assure16Bit_() {

        this.assureUncompressed_();

        if (this.bitDepth != "16") {

            this.toBitDepth("16");

        }

    }

    /**

     * Uncompress the samples in case of a compressed file.

     * @private

     */

    assureUncompressed_() {

        if (this.bitDepth == "8a") {

            this.fromALaw();

        } else if(this.bitDepth == "8m") {

            this.fromMuLaw();

        } else if (this.bitDepth == "4") {

            this.fromIMAADPCM();

        }

    }

    /**

     * Interleave the samples in case they are de-Interleaved.

     * @private

     */

    assureInterleaved_() {

        if (!this.isInterleaved) {

            this.interleave();

        }

    }

    /**

     * Set up to work wih big-endian or little-endian files.

     * The types used are changed to LE or BE. If the

     * the file is big-endian (RIFX), true is returned.

     * @return {boolean} True if the file is RIFX.

     * @private

     */

    LEorBE_() {

        let bigEndian = this.container == "RIFX";

        uInt8_.be = bigEndian;

        uInt16_.be = bigEndian;

        uInt32_.be = bigEndian;

        return bigEndian;

    }

    /**

     * Find a chunk by its FourCC in a array of RIFF chunks.

     * @param {!Object<string, Object>} chunks The wav file chunks.

     * @param {!string} fourCC The chunk fourCC.

     * @return {Object|null}

     * @private

     */

    findChunk_(chunks, fourCC) {

        for (let i = 0; i<chunks.length; i++) {

            if (chunks[i]["chunkId"] == fourCC) {

                return chunks[i];

            }

        }

        return null;

    }

    /**

     * Read the RIFF chunk a wave file.

     * @param {!Uint8Array|!Array<number>} bytes A wav buffer.

     * @throws {Error} If no "RIFF" chunk is found.

     * @private

     */

    readRIFFChunk_(bytes) {

        this.container = byteData_.unpackArray(

            bytes.slice(0, 4), byteData_.chr);

        if (this.container != "RIFF" && this.container != "RIFX") {

            throw Error("Not a supported format.");

        }

        this.LEorBE_();

        this.chunkSize = byteData_.unpack(bytes.slice(4, 8), uInt32_);

        this.format = byteData_.unpackArray(

            bytes.slice(8, 12), byteData_.chr);

        if (this.format != "WAVE") {

            throw Error("Could not find the 'WAVE' format identifier");

        }

    }

    /**

     * Read the "fmt " chunk of a wave file.

     * @param {!Object<string, *>} chunks The wav file chunks.

     * @throws {Error} If no "fmt " chunk is found.

     * @private

     */

    readFmtChunk_(chunks) {

        let chunk = this.findChunk_(chunks, "fmt ");

        if (chunk) {

            this.fmt.chunkId = "fmt ";

            this.fmt.chunkSize = chunk["chunkSize"];

            this.fmt.audioFormat = byteData_.unpack(

                chunk["chunkData"].slice(0, 2), uInt16_);

            this.fmt.numChannels = byteData_.unpack(

                chunk["chunkData"].slice(2, 4), uInt16_);

            this.fmt.sampleRate = byteData_.unpack(

                chunk["chunkData"].slice(4, 8), uInt32_);

            this.fmt.byteRate = byteData_.unpack(

                chunk["chunkData"].slice(8, 12), uInt32_);

            this.fmt.blockAlign = byteData_.unpack(

                chunk["chunkData"].slice(12, 14), uInt16_);

            this.fmt.bitsPerSample = byteData_.unpack(

                    chunk["chunkData"].slice(14, 16), uInt16_);

            this.readFmtExtension_(chunk);

        } else {

            throw Error("Could not find the 'fmt ' chunk");

        }

    }

    /**

     * Read the "fmt " chunk extension.

     * @param {!Object<string, *>} chunk The "fmt " chunk.

     * @private

     */

    readFmtExtension_(chunk) {

        let chunkData = chunk["chunkData"];

        if (this.fmt.chunkSize > 16) {

            this.fmt.cbSize = byteData_.unpack(

                chunkData.slice(16, 18), uInt16_);

            if (this.fmt.chunkSize > 18) {

                this.fmt.validBitsPerSample = byteData_.unpack(

                    chunkData.slice(18, 20), uInt16_);

                if (this.fmt.chunkSize > 20) {

                    this.fmt.dwChannelMask = byteData_.unpack(

                        chunkData.slice(20, 24), uInt32_);

                    this.fmt.subformat = [

                        byteData_.unpack(

                            chunkData.slice(24, 28), uInt32_),

                        byteData_.unpack(

                            chunkData.slice(28, 32), uInt32_),

                        byteData_.unpack(

                            chunkData.slice(32, 36), uInt32_),

                        byteData_.unpack(

                            chunkData.slice(36, 40), uInt32_)];

                }

            }

        }

    }

    /**

     * Read the "fact" chunk of a wav file.

     * @param {!Object<string, *>} chunks The wav file chunks.

     * @throws {Error} If no "fact" chunk is found.

     * @private

     */

    readFactChunk_(chunks) {

        let chunk = this.findChunk_(chunks, "fact");

        if (chunk) {

            this.fact.chunkId = "fact";

            this.fact.chunkSize = chunk["chunkSize"];

            this.fact.dwSampleLength = byteData_.unpack(

                chunk["chunkData"].slice(0, 4), uInt32_);

        } else if (this.enforceFact_) {

            throw Error("Could not find the 'fact' chunk");

        }

    }

    /**

     * Read the "cue " chunk of a wave file.

     * @param {!Object<string, *>} chunks The RIFF file chunks.

     * @private

     */

    readCueChunk_(chunks) {

        let chunk = this.findChunk_(chunks, "cue ");

        if (chunk) {

            let chunkData = chunk["chunkData"];

            this.cue.chunkId = "cue ";

            this.cue.chunkSize = chunk["chunkSize"];

            this.cue.dwCuePoints = byteData_.unpack(

                chunkData.slice(0, 4), uInt32_);

            for (let i=0; i<this.cue.dwCuePoints; i++) {

                let offset = 4 + (i * 24);

                this.cue.points.push(

                    {

                        "dwName": byteData_.unpack(

                            chunkData.slice(offset, offset + 4), uInt32_),

                        "dwPosition": byteData_.unpack(

                            chunkData.slice(offset + 4, offset + 8), uInt32_),

                        "fccChunk": byteData_.unpack(

                            chunkData.slice(offset + 8, offset + 12), byteData_.fourCC),

                        "dwChunkStart": byteData_.unpack(

                            chunkData.slice(offset + 12, offset + 16), uInt32_),

                        "dwBlockStart": byteData_.unpack(

                            chunkData.slice(offset + 16, offset + 20), uInt32_),

                        "dwSampleOffset": byteData_.unpack(

                            chunkData.slice(offset + 20, offset + 24), uInt32_),

                    });

            }

        }

    }

    /**

     * Read the "data" chunk of a wave file.

     * @param {!Object<string, *>} chunks The RIFF file chunks.

     * @param {!Object<string, *>} options Type options.

     * @throws {Error} If no "data" chunk is found.

     * @private

     */

    readDataChunk_(chunks, options) {

        let chunk = this.findChunk_(chunks, "data");

        if (chunk) {

            this.data.chunkId = "data";

            this.data.chunkSize = chunk["chunkSize"];

            this.samplesFromBytes_(chunk["chunkData"], options);

        } else {

            throw Error("Could not find the 'data' chunk");

        }

    }

    /**

     * Read the "bext" chunk of a wav file.

     * @param {!Object<string, *>} chunks The wav file chunks.

     * @private

     */

    readBextChunk_(chunks) {

        let chunk = this.findChunk_(chunks, "bext");

        if (chunk) {

            let chunkData = chunk["chunkData"];

            this.head_ = 0;

            this.bext =  {

                "chunkId": "bext",

                "chunkSize": chunkData.length,

                "description": this.readString_(chunkData, 256),

                "originator": this.readString_(chunkData, 32),

                "originatorReference": this.readString_(chunkData, 32),

                "originationDate": this.readString_(chunkData, 10),

                "originationTime": this.readString_(chunkData, 8),

                "timeReference": [

                        this.readFromChunk_(chunkData, uInt32_),

                        this.readFromChunk_(chunkData, uInt32_)], 

                "version": this.readFromChunk_(

                    chunkData, uInt16_),

                "UMID": this.readString_(chunkData, 64),

                "loudnessValue": this.readFromChunk_(

                    chunkData, uInt16_),

                "loudnessRange": this.readFromChunk_(

                    chunkData, uInt16_),

                "maxTruePeakLevel": this.readFromChunk_(

                    chunkData, uInt16_),

                "maxMomentaryLoudness": this.readFromChunk_(

                    chunkData, uInt16_),

                "maxShortTermLoudness": this.readFromChunk_(

                    chunkData, uInt16_),

                "reserved": this.readString_(chunkData, 180),

                "codingHistory": this.readString_(

                    chunkData, chunkData.length - 602),

            };

        }

    }

    /**

     * Read bytes as a string from a RIFF chunk.

     * @param {!Array<number>|!Uint8Array} bytes The bytes.

     * @param {!number} maxSize the max size of the string.

     * @return {!string} The string.

     * @private

     */

    readString_(bytes, maxSize) {

        let str = "";

        for (let i=0; i<maxSize; i++) {

            str += byteData_.unpack([bytes[this.head_]], byteData_.chr);

            this.head_++;

        }

        return str;

    }

    /**

     * Read a number from a chunk.

     * @param {!Array<number>|!Uint8Array} bytes The chunk bytes.

     * @param {!Object<string, *>} bdType The byte-data corresponding type.

     * @return {!number} The number.

     * @private

     */

    readFromChunk_(bytes, bdType) {

        let size = bdType.bits / 8;

        let value = byteData_.unpack(

            bytes.slice(this.head_, this.head_ + size), bdType);

        this.head_ += size;

        return value;

    }

    /**

     * Write a variable size string as bytes.

     * If the string is smaller than the max size it 

     * is filled with 0s.

     * @param {!string} str The string to be written as bytes.

     * @param {!number} maxSize the max size of the string.

     * @return {!Array<number>} The bytes.

     * @private

     */

    writeString_(str, maxSize) {

        let bytes = byteData_.packArray(str, byteData_.chr);

        for (let i=bytes.length; i<maxSize; i++) {

            bytes.push(0);

        }

        return bytes;

    }

    /**

     * Turn the samples to bytes.

     * @param {!Object<string, *>} options Type options.

     * @return {!Array<number>} The bytes.

     * @private

     */

    samplesToBytes_(options) {

        options.bits = this.fmt.bitsPerSample == 4 ?

            8 : this.fmt.bitsPerSample;

        options.signed = options.bits == 8 ? false : true;

        options.float = (this.fmt.audioFormat == 3  ||

                this.fmt.bitsPerSample == 64) ? true : false;

        let bytes = byteData_.packArray(

            this.data.samples, new byteData_.Type(options));

        if (bytes.length % 2) {

            bytes.push(0);

        }

        return bytes;

    }

    /**

     * Turn bytes to samples and load them in the data.samples property.

     * @param {!Array<number>|!Uint8Array} bytes The bytes.

     * @param {!Object<string, *>} options Type options.

     * @private

     */

    samplesFromBytes_(bytes, options) {

        options.bits = this.fmt.bitsPerSample == 4 ?

            8 : this.fmt.bitsPerSample;

        options.signed = options.bits == 8 ? false : true;

        options.float = (this.fmt.audioFormat == 3 || 

            this.fmt.bitsPerSample == 64) ? true : false;

        options.single = false;

        this.data.samples = byteData_.unpackArray(

            bytes, new byteData_.Type(options));

    }

    /**

     * Return the bytes of the "bext" chunk.

     * @return {!Array<number>} The "bext" chunk bytes.

     * @private

     */

    getBextBytes_() {

        if (this.bext.chunkId) {

            return [].concat(

                byteData_.packArray(this.bext.chunkId, byteData_.chr),

                byteData_.pack(this.bext.chunkSize, uInt32_),

                this.writeString_(this.bext.description, 256),

                this.writeString_(this.bext.originator, 32),

                this.writeString_(this.bext.originatorReference, 32),

                this.writeString_(this.bext.originationDate, 10),

                this.writeString_(this.bext.originationTime, 8),

                byteData_.pack(this.bext.timeReference[0], uInt32_),

                byteData_.pack(this.bext.timeReference[1], uInt32_),

                byteData_.pack(this.bext.version, uInt16_),

                this.writeString_(this.bext.UMID, 64),

                byteData_.pack(this.bext.loudnessValue, uInt16_),

                byteData_.pack(this.bext.loudnessRange, uInt16_),

                byteData_.pack(this.bext.maxTruePeakLevel, uInt16_),

                byteData_.pack(this.bext.maxMomentaryLoudness, uInt16_),

                byteData_.pack(this.bext.maxShortTermLoudness, uInt16_),

                this.writeString_(this.bext.reserved, 180),

                this.writeString_(

                    this.bext.codingHistory,

                    this.bext.chunkSize - 602));

        }

        return [];

    }

    /**

     * Return the bytes of the "cue " chunk.

     * @return {!Array<number>} The "cue " chunk bytes.

     * @private

     */

    getCueBytes_() {

        if (this.cue.chunkId) {

            return [].concat(

                byteData_.packArray(this.cue.chunkId, byteData_.chr),

                byteData_.pack(this.cue.chunkSize, uInt32_),

                byteData_.pack(this.cue.dwCuePoints, uInt32_),

                this.getCuePointsBytes_());

        }

        return [];

    }

    /**

     * Return the bytes of the "cue " points.

     * @return {!Array<number>} The "cue " points as an array of bytes.

     * @private

     */

    getCuePointsBytes_() {

        let points = [];

        for (let i=0; i<this.cue.dwCuePoints; i++) {

            points = points.concat(

                    byteData_.pack(this.cue.points[i].dwName, uInt32_),

                    byteData_.pack(this.cue.points[i].dwPosition, uInt32_),

                    byteData_.pack(this.cue.points[i].fccChunk, byteData_.fourCC),

                    byteData_.pack(this.cue.points[i].dwChunkStart, uInt32_),

                    byteData_.pack(this.cue.points[i].dwBlockStart, uInt32_),

                    byteData_.pack(this.cue.points[i].dwSampleOffset, uInt32_)

                );

        }

        return points;

    }

    /**

     * Return the bytes of the "fact" chunk.

     * @return {!Array<number>} The "fact" chunk bytes.

     * @private

     */

    getFactBytes_() {

        if (this.fact.chunkId) {

            return [].concat(

                byteData_.packArray(this.fact.chunkId, byteData_.chr),

                byteData_.pack(this.fact.chunkSize, uInt32_),

                byteData_.pack(this.fact.dwSampleLength, uInt32_));

        }

        return [];

    }

    /**

     * Return the bytes of the "fmt " chunk.

     * @return {!Array<number>} The "fmt" chunk bytes.

     * @private

     * @throws {Error} if no "fmt " chunk is present.

     */

    getFmtBytes_() {

        if (this.fmt.chunkId) {

            return [].concat(

                byteData_.packArray(this.fmt.chunkId, byteData_.chr),

                byteData_.pack(this.fmt.chunkSize, uInt32_),

                byteData_.pack(this.fmt.audioFormat, uInt16_),

                byteData_.pack(this.fmt.numChannels, uInt16_),

                byteData_.pack(this.fmt.sampleRate, uInt32_),

                byteData_.pack(this.fmt.byteRate, uInt32_),

                byteData_.pack(this.fmt.blockAlign, uInt16_),

                byteData_.pack(this.fmt.bitsPerSample, uInt16_),

                this.getFmtExtensionBytes_()

            );

            throw Error("Could not find the 'fmt ' chunk");

        }

    }

    /**

     * Return the bytes of the fmt extension fields.

     * @return {!Array<number>} The fmt extension bytes.